package LeetCode;

import java.util.ArrayDeque;
import java.util.Deque;

public class No385 {
    public static void main(String[] args) {

    }
    int index = 0;

    public NestedInteger deserialize(String s) {

        //判断第一个是否是[，不是的话就代表只有一个数字，是的话继续判断，但遇到一个[时，就需要压一个NestedInteger对象入栈，nagative用于数字符号判断
        //当遇到，或]时，先判断前一位是否为数字，是的话创建一个NestedInteger对象，加入到栈顶的队列中，如果是]时，如果栈里有两个及以上的NestedInteger的话
        //就抛出一个，加入到下一个NestedInteger的队列中。
        if (s.charAt(0) != '[') {
            return new NestedInteger(Integer.parseInt(s));
        }
        Deque<NestedInteger> stack = new ArrayDeque<NestedInteger>();
        int num = 0;
        boolean negative = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '-') {
                negative = true;
            } else if (Character.isDigit(c)) {
                num = num * 10 + c - '0';
            } else if (c == '[') {
                stack.push(new NestedInteger());
            } else if (c == ',' || c == ']') {
                if (Character.isDigit(s.charAt(i - 1))) {
                    if (negative) {
                        num *= -1;
                    }
                    stack.peek().add(new NestedInteger(num));
                }
                num = 0;
                negative = false;
                if (c == ']' && stack.size() > 1) {
                    NestedInteger ni = stack.pop();
                    stack.peek().add(ni);
                }
            }
        }
        return stack.pop();

//        if (s.charAt(index) == '[') {
//            index++;
//            NestedInteger ni = new NestedInteger();
//            while (s.charAt(index) != ']') {
//                ni.add(deserialize(s));
//                if (s.charAt(index) == ',') {
//                    index++;
//                }
//            }
//            index++;
//            return ni;
//        } else {
//            boolean negative = false;
//            if (s.charAt(index) == '-') {
//                negative = true;
//                index++;
//            }
//            int num = 0;
//            while (index < s.length() && Character.isDigit(s.charAt(index))) {
//                num = num * 10 + s.charAt(index) - '0';
//                index++;
//            }
//            if (negative) {
//                num *= -1;
//            }
//            return new NestedInteger(num);
//        }
    }
}
